package 思维题;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

/**
 * @author aodre , QQ : 480029069
 * @date 2023/6/4 16:06
 */
public class lc周赛348思维题6472 {


    public long matrixSumQueries(int n, int[][] queries) {

        long sum = 0;
        Map<Integer,Integer> mapRow = new HashMap<>(n);
        Map<Integer,Integer> mapCol = new HashMap<>(n);
        // 用数组 模拟 map 也可以 ，不如直接 用map 来的 直接
        for(int i = 0; i < queries.length;i++){
            if(queries[i][0] == 0){
                mapRow.put(queries[i][1],i);
            }else{
                mapCol.put(queries[i][1],i);
            }
        }
        long rowSum = 0;
        for(Map.Entry<Integer,Integer> entry : mapRow.entrySet()){
            rowSum += queries[entry.getValue()][2];
        }
        sum += rowSum * n;
        for(Map.Entry<Integer,Integer> entry : mapCol.entrySet()){
            sum += queries[entry.getValue()][2] * n;
        }
        // 减去 列 覆盖的行的 差值 也可以 在上面写， 但是最后减去也可以
        sum -= rowSum * mapCol.size();
        return sum ;
    }



    public long myVersion(int n,int [][]queries){
        Set<Integer> row = new HashSet<>(), col = new HashSet<>();
        long sum = 0;
        // 倒序， 边遍历 ， 边计算
        for(int i = queries.length - 1;i >= 0;i--){
            boolean flag = (queries[i][0] == 0 ? row : col).add(queries[i][1]); // 如果 倒序过程中，发现某一个行，或者列 以及重合了， 直接不用计算了， 反正已经被覆盖了
            if(flag){ // 说明该列 或者 该行， 是第一次 出现，累加
                //还要注意一点， 行 要去计算col 的 忽略， 而列 要去计算 row 的忽略 ， 这里的忽略， 也就是重合点的个数
                sum += queries[i][2] * (n - (queries[i][0] == 0 ? col : row).size());// 这里有些抽象，就是 不计算 row 和col 重合的点， 不进行计算了， 因为倒序， 已经累加过了！
            }
        }

        return sum;
    }




    /*
     这是 arignote的做法， 非常的简洁，但是 理解起来有点难度
     倒序的思想来做非常的巧妙， 正序 来做 不太好做， 上面的解法就是个例子
     */

    public long matrixSumQueries1(int n, int[][] queries) {
        HashSet<Integer> row = new HashSet<>(), col = new HashSet<>();
        long sum = 0;
        for (int i = queries.length - 1; i >= 0; i--) {
            sum += !(queries[i][0] == 0 ? row : col).add(queries[i][1]) ? 0
                    : queries[i][2] * (n - (queries[i][0] == 0 ? col : row).size());
        }
        return sum;
    }


}
